This graph link depends on #100, although I don't think we need to block this PR on #100 landing. And this paragraph is sounding a lot like Make, Bazel, Terraform, etc. ;)

And this paragraph is sounding a lot like Make, Bazel, Terraform, etc. ;)

mini version of these :)

The asset is an map of all the assets...

This reads a bit awkwardly (one asset containing many?). Maybe just drop this last sentence?

👍

This feels like a Merkle DAGs. Maybe our state structure should just be a DAG? That would build dependencies into the structure directly. I'm sure there are many off-the-shelf Merkle DAG libraries in Go (here's one), but rolling our own for this special case will probably not be hard either. Something like:

type State struct {
  Objects map[string]Asset // store for all the assets
  Root    string  // hash for the root asset
}

type Asset struct {
  Parents []string // hashes for our parents
  Name string
  Path string  // is this really important?  I'd have expected we can just use `Name` for this.
  Data []byte
}

👍

I'd expect []byte for this.

I thought we decided that we gonna just throw our hands?

That's still an valid outcome.

Shouldn't the parent include everything but the final targets ?
I would expect some tree-list structure, besides how is this struct related to the Assets struct below?

I was thinking something like:

type State struct {
    Assets []Asset; // Final leaf assets
}
type Asset struct {
    Name string
    Parents []Asset
    Dirty bool
    Hash string
    Data []byte
    ...
}

The state object is an hashmap containing all the assets, not just the final. Each asset will use this object to fetch its dependencies.

Why did this end up being a map? I think it should be a slice of hash strings; see here and here.